# 导入 pygame 库。这是制作游戏所必需的，它包含了所有图形、声音和事件处理的功能。
import pygame
import sys
import random
import math
from .score_utils import load_high_score
from .constant import SNAKE_SKINS
from .sound_manager import Sound


# <--- 修改部分开始 --->
# --- 1. 更新调色板，以匹配“中心黑，四周蓝”的效果 ---
COLOR_GRADIENT_CENTER = (0, 0, 0)  # 中心：纯黑
COLOR_GRADIENT_EDGE = (10, 20, 70)  # 边缘：科技蓝，一种非常深的科技蓝
COLOR_PARTICLE_BLUE = (0, 191, 255)
COLOR_PARTICLE_YELLOW = (255, 215, 0)
COLOR_HEXAGON_LINE = (255, 255, 255, 30)
# 第四个值 30 是 Alpha (透明度)，范围是 0-255，30 表示这个线条是非常透明的。

# <--- 修改部分结束 --->


# --- 2. 核心元素类和辅助函数 (这部分代码保持不变) ---
# (这里的 Particle, MovingHexagon, create_glow_surface, create_radial_gradient_background
#  与 start_screen.py 中的代码完全相同，是复用的动态背景效果)
# 定义一个“粒子”类。类（Class）就像一个蓝图，用来创建很多相似但又独立的东西（对象）。
# 这个蓝图定义了每个背景光点的行为。
class Particle:
    # 类的“初始化方法”（或“构造函数”）。
    def __init__(self, x, y):
        # self.anchor_pos 是粒子的“锚点”，即它的活动中心。pygame.Vector2 是一种能方便处理 (x, y) 坐标的对象。
        self.anchor_pos = pygame.Vector2(x, y)
        # self.pos 是粒子的当前实际位置，初始时和锚点相同。
        self.pos = pygame.Vector2(x, y)
        # self.angle1 和 self.angle2 是两个随机角度，用于控制复杂的环绕运动。
        self.angle1 = random.uniform(0, 2 * math.pi)
        self.angle2 = random.uniform(0, 2 * math.pi)
        # self.speed1 和 self.speed2 是两个随机的旋转速度
        self.speed1 = random.uniform(0.01, 0.03)
        self.speed2 = random.uniform(0.01, 0.03)
        # self.radius1 和 self.radius2 是两个随机的旋转半径。
        self.radius1 = random.uniform(5, 15)
        self.radius2 = random.uniform(5, 15)
        # 随机选择一个颜色（蓝色或黄色）。
        self.color = random.choice([COLOR_PARTICLE_BLUE, COLOR_PARTICLE_YELLOW])
        # 随机设置粒子本身的大小。
        self.radius = random.uniform(1, 2.5)

    # 粒子的“更新方法”。这个方法会在游戏的每一帧被调用，用来计算粒子的新位置。
    def update(self):
        # 两个角度各自增加自己的速度，实现旋转
        self.angle1 += self.speed1
        self.angle2 += self.speed2
        # 核心动画！通过两个叠加的圆周运动（三角函数）来计算 x 和 y 的偏移量。
        # 这会让粒子在一个小范围内进行一种复杂的、无规则的“绕圈”运动。
        offset_x = math.cos(self.angle1) * self.radius1 + math.cos(self.angle2) * self.radius2
        offset_y = math.sin(self.angle1) * self.radius1 + math.sin(self.angle2) * self.radius2
        # 粒子的最终位置 = 它的锚点中心 + 刚刚算出来的偏移量。
        self.pos = self.anchor_pos + pygame.Vector2(offset_x, offset_y)

    # 粒子的“绘制方法”。在每一帧被调用，把粒子画在屏幕上
    def draw(self, surface, glow_image):
        size = int(self.radius * 6)
        # 把通用的光晕图片 (glow_image) 缩放到需要的大小。
        scaled_glow = pygame.transform.scale(glow_image, (size, size))
        # 复制一份缩放后的光晕图，准备给它上色。
        colored_glow = scaled_glow.copy()
        # 给光晕图上色。special_flags=pygame.BLEND_RGBA_MULT 是一种混合模式，会把光晕的灰色和粒子的彩色叠在一起。
        colored_glow.fill(self.color, special_flags=pygame.BLEND_RGBA_MULT)
        # 把上了色的光晕画到传入的画布 (surface) 上。
        # special_flags=pygame.BLEND_RGBA_ADD 是一种“滤色”或“添加”混合模式，会让光晕叠加时产生更亮的发光效果。
        surface.blit(colored_glow, self.pos - pygame.Vector2(size / 2, size / 2), special_flags=pygame.BLEND_RGBA_ADD)

# 定义一个“移动的六边形”类。
class MovingHexagon:
    def __init__(self, x, y, size, screen_w, screen_h):
        # self.pos 是六边形中心点的 (x, y) 坐标
        self.pos = pygame.Vector2(x, y)
        # self.size 是六边形的大小（外接圆半径）。
        self.size = size
        # self.angle 是六边形当前的旋转角度。
        self.angle = random.uniform(0, 360)
        # self.rotation_speed 是六边形的旋转速度（可正可负）
        self.rotation_speed = random.uniform(-0.1, 0.1)
        # self.vel 是六边形的移动速度向量 (velocity)
        self.vel = pygame.Vector2(random.uniform(-0.5, 0.5), random.uniform(-0.5, 0.5))
        # 存储屏幕宽高，用于做边界判断
        self.screen_w, self.screen_h = screen_w, screen_h
        # 限制六边形的最大移动速度。
        self.max_speed = 0.5
        # 模拟阻力。每次更新时速度都会乘以 0.995，让它慢慢减速，不会无限加速。
        self.drag = 0.995

    # 六边形的更新方法
    def update(self):
        # 模拟一个微小的随机“推力”，让六边形的运动看起来更自然、无规则
        random_force = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1))
        random_force.scale_to_length(0.02)# scale_to_length 保证这个力的大小总是 0.02。
        """
        .scale_to_length是pygame.math.Vector2（二维向量） 这个“类”自带的一个方法（函数）
        1.scale 的意思是“缩放”。   length 的意思是“长度”（在向量里也叫“模”）。
        这个函数的唯一功能是：在 保持 向量方向不变的前提下，把它的 长度 强制缩放（拉伸或压缩）到你指定的新长度
        2..scale_to_length() 不会“原地”修改 random_force。
        它会“返回”一个“新的”、长度为 0.02 的向量
        必须“接住”这个新向量
        """
        self.vel += random_force
        # 如果速度超过了最大限制
        if self.vel.length() > self.max_speed:
            # 就把速度降回最大值。
            self.vel.scale_to_length(self.max_speed)
        # 施加阻力，让速度按百分比衰减。
        self.vel *= self.drag
        # 根据最终的速度更新六边形的位置
        self.pos += self.vel
        # 根据旋转速度更新六边形的角度
        self.angle += self.rotation_speed

        # 如果六边形完全移出了右边界
        if self.pos.x > self.screen_w + self.size: self.pos.x = -self.size# 就把它瞬移到左边界外。
        # 如果完全移出了左边界
        if self.pos.x < -self.size: self.pos.x = self.screen_w + self.size# 就瞬移到右边界外。
        if self.pos.y > self.screen_h + self.size: self.pos.y = -self.size
        if self.pos.y < -self.size: self.pos.y = self.screen_h + self.size

    # 一个辅助方法，用于计算六边形当前的 6 个顶点坐标。
    def get_points(self):
        points = []
        # 循环 6 次，计算 6 个顶点
        for i in range(6):
            # 核心数学！通过三角函数 (sin, cos) 计算绕中心点旋转的坐标。
            # i * 60 保证了 6 个点均匀分布在 360 度上
            point_angle = math.radians(self.angle + i * 60)
            """
            math.radians(...)
            math.radians: 这是“单位转换”函数。
            功能：它的作用是把一个我们人类熟悉的**“度”（比如 120 度），
            转换成 Python 的 math.sin() 和 math.cos() 函数能看懂的“弧度”（比如 2.09）。
            """
            x = self.pos.x + self.size * math.cos(point_angle)
            y = self.pos.y + self.size * math.sin(point_angle)
            points.append((x, y))
        # 返回 6 个 (x, y) 坐标的列表
        return points

    # 六边形的绘制方法
    def draw(self, surface):
        # 先获取 6 个顶点的当前位置
        points = self.get_points()
        # 确保至少有两个点（防止bug）
        if len(points) > 1:
            # pygame.draw.lines 用来画多条连接的线。
            # surface: 在哪画。
            # COLOR_HEXAGON_LINE: 用什么颜色（那个半透明的白色）。
            # True: 表示画完最后一条线后，是否要从最后一个点连回第一个点（闭合图形）。
            # points: 顶点的列表。
            # 1: 线条的宽度。
            pygame.draw.lines(surface, COLOR_HEXAGON_LINE, True, points, 1)

# 辅助函数：创建一个通用的圆形光晕图像（给 Particle 类的 draw 方法使用）
def create_glow_surface(radius, color):
    # 创建一个支持透明度的临时画布
    surf = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA)
    """
    1.pygame.Surface() 第一个参数，必须是这块新画布的“尺寸 (Size)”
    “尺寸”永远、必须是用一个元组 (Tuple) 来表示的，这个元组必须包含两个值：(宽度, 高度)
    """
    # 在这个画布的中心画一个实心圆
    pygame.draw.circle(surf, color, (radius, radius), radius)
    # 返回这个画好了圆的画布
    return surf

# 辅助函数：创建一个径向渐变的背景图像
def create_radial_gradient_background(width, height, center_color, edge_color):
    """创建从中心向四周扩散的径向渐变背景"""
    # 创建一个和屏幕一样大，但不支持透明度的画布
    bg = pygame.Surface((width, height))
    # 计算画布的中心点
    center_x, center_y = width // 2, height // 2
    # 计算从中心到角落的最大半径（使用勾股定理）
    max_radius = int(math.sqrt(center_x ** 2 + center_y ** 2))
    # 循环！从最大半径开始，一圈一圈画圆，半径每次减 1，直到 0
    for r in range(max_radius, 0, -1):
        # 计算当前半径占最大半径的比例 (0.0 到 1.0)
        progress = r / max_radius
        # 核心！根据这个比例，在“边缘颜色”和“中心颜色”之间进行线性插值，计算出当前这一圈圆的颜色。
        color = (
            int(edge_color[0] + (center_color[0] - edge_color[0]) * (1 - progress)),
            int(edge_color[1] + (center_color[1] - edge_color[1]) * (1 - progress)),
            int(edge_color[2] + (center_color[2] - edge_color[2]) * (1 - progress))
        )
        # 用计算出的颜色，画一个实心圆
        pygame.draw.circle(bg, color, (center_x, center_y), r)
    return bg# 返回这个已经画满渐变圆的画布


# --- 3. 全新的主函数 ---
# 这是结束界面的主函数，是这个文件的“大脑”，负责协调所有元素的运作。
def draw_end_screen(screen, screen_w, screen_h, sound_manager, final_score, settings):
    # 创建一个时钟对象，用来控制帧率 (FPS)。
    clock = pygame.time.Clock()

    # 调用上面的背景生成函数时，交换中心色和边缘色的位置
    # 中心色传入 COLOR_GRADIENT_CENTER (黑色)
    # 边缘色传入 COLOR_GRADIENT_EDGE (蓝色)
    background_surface = create_radial_gradient_background(screen_w, screen_h, COLOR_GRADIENT_CENTER,
                                                           COLOR_GRADIENT_EDGE)

    # 初始化动态元素
    particles = [Particle(random.uniform(0, screen_w), random.uniform(0, screen_h)) for _ in range(300)]
    glow_image = create_glow_surface(32, (100, 100, 100))
    hexagons = [MovingHexagon(random.uniform(0, screen_w), random.uniform(0, screen_h),
                              random.uniform(50, 100), screen_w, screen_h) for _ in range(20)]

    # 字体和UI
    #调整并新增了多种字体以适应新UI
    font_title = pygame.font.SysFont("Simsun", 72, bold=True)
    font_option_title = pygame.font.SysFont("Simsun", 40, bold=True)
    font_option = pygame.font.SysFont("Simsun", 20, bold=True)
    font_score = pygame.font.SysFont("Simsun", 28)
    font_button = pygame.font.SysFont("Simsun", 32, bold=True)
    # <--- 【修改 1/4】新增：为弹出窗口增加字体 --->
    font_dialog_title = pygame.font.SysFont("Simsun", 28, bold=True)
    font_dialog_button = pygame.font.SysFont("Simsun", 22, bold=True)
    # <--- 【修改 1/4】结束 --->

    # --- 修改: 为800x800屏幕调整了按钮布局 ---
    btn_width, btn_height, btn_y_gap, btn_x_gap = 180, 45, 100, 20
    start_y = 270

    mode_buttons = {
        'simple': pygame.Rect(screen_w / 2 - btn_width * 1.5 - btn_x_gap, start_y, btn_width, btn_height),
        'ai': pygame.Rect(screen_w / 2 - btn_width * 0.5, start_y, btn_width, btn_height),
        'endless': pygame.Rect(screen_w / 2 + btn_width * 0.5 + btn_x_gap, start_y, btn_width, btn_height)
    }
    skin_buttons = {
        'default': pygame.Rect(screen_w / 2 - btn_width * 1.5 - btn_x_gap, start_y + btn_y_gap, btn_width, btn_height),
        'fire': pygame.Rect(screen_w / 2 - btn_width * 0.5, start_y + btn_y_gap, btn_width, btn_height),
        'ice': pygame.Rect(screen_w / 2 + btn_width * 0.5 + btn_x_gap, start_y + btn_y_gap, btn_width, btn_height)
    }
    logo_buttons = {
        'cloud': pygame.Rect(screen_w / 2 - btn_width * 1.5 - btn_x_gap, start_y + 2 * btn_y_gap, btn_width,
                             btn_height),
        'aurora': pygame.Rect(screen_w / 2 - btn_width * 0.5, start_y + 2 * btn_y_gap, btn_width, btn_height),
        'whale': pygame.Rect(screen_w / 2 + btn_width * 0.5 + btn_x_gap, start_y + 2 * btn_y_gap, btn_width, btn_height)
    }

    # 新增背景颜色按钮的定义
    bgcolor_buttons = {
        'grey': pygame.Rect(screen_w / 2 - btn_width * 1.5 - btn_x_gap, start_y + 3 * btn_y_gap, btn_width, btn_height),
        'green': pygame.Rect(screen_w / 2 - btn_width * 0.5, start_y + 3 * btn_y_gap, btn_width, btn_height),
        'yellow': pygame.Rect(screen_w / 2 + btn_width * 0.5 + btn_x_gap, start_y + 3 * btn_y_gap, btn_width,
                              btn_height)
    }
    back_button = pygame.Rect(screen_w // 2 - 180, 710, 360, 60)

    # <--- 【修改 2/4】新增：定义退出确认窗口所需的状态和UI元素 --->
    show_exit_dialog = False  # 用于控制弹窗是否显示的标志
    dialog_rect = pygame.Rect(screen_w // 2 - 200, screen_h // 2 - 100, 400, 200)  # 弹窗主体
    confirm_button_rect = pygame.Rect(dialog_rect.centerx - 125, dialog_rect.bottom - 70, 100, 40)  # 确定按钮
    cancel_button_rect = pygame.Rect(dialog_rect.centerx + 25, dialog_rect.bottom - 70, 100, 40)  # 取消按钮
    # <--- 【修改 2/4】结束 --->

    # 结束界面的“主循环”。这个循环会一直运行，直到函数返回。
    while True:
        # 在每一帧的开始，获取鼠标的当前 (x, y) 坐标
        mouse_pos = pygame.mouse.get_pos()
        # --- 事件处理循环 ---
        # 遍历 Pygame 在这一帧中捕获到的所有用户操作（如按键、鼠标点击等）。
        for event in pygame.event.get():
            # 步骤A: 捕获窗口关闭事件(点击'X')，不再直接退出，而是设置标志位
            if event.type == pygame.QUIT:
                # 不再是 "pygame.quit(); sys.exit()"
                # 而是将状态标志设置为 True，表示“需要显示弹窗”。
                show_exit_dialog = True
                # 使用 continue 关键字，立即跳到下一次 `while True` 循环。
                # 这样可以防止本轮循环后续的 `if show_exit_dialog:` 被错误执行。
                continue  # 立刻进入下一轮循环，以便绘制弹窗，不再处理本轮后续事件

            # 步骤B: 如果弹窗已显示，则只处理弹窗内的事件
            if show_exit_dialog:
                if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                    # 点击“确定”按钮，则退出游戏，检查鼠标是否点击了“确定”按钮
                    if confirm_button_rect.collidepoint(mouse_pos):
                        pygame.quit()
                        sys.exit()
                    # 点击“取消”按钮，则关闭弹窗
                    if cancel_button_rect.collidepoint(mouse_pos):
                        show_exit_dialog = False
                # 关键！在“弹窗模式”下，执行 continue。
                # 这会跳过下面所有的“步骤C”代码，防止玩家在弹窗显示时还能点到背景里的设置按钮。
                continue  # 关键！阻止事件继续传递到下层的主界面按钮

            ## --- 修改标记：在这里增加对键盘ENTER键的监听 --- ##
            # 步骤C: 主界面事件处理 (仅在弹窗不显示时执行)
            # 如果事件是“键盘按下”
            if event.type == pygame.KEYDOWN:
                # 并且按下的键是“回车键”（在Pygame中叫K_RETURN）
                if event.key == pygame.K_RETURN:
                    # 就执行和点击按钮完全一样的操作：返回信号和设置，以开始新游戏
                    # 如果是，就模拟点击了“开始新游戏”按钮。
                    # 'return' 会立刻结束这个函数，并把值返回给 main.py
                    return "back_to_start", settings

            # 处理对新功能按钮的鼠标点击事件 --- ##
            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                # 遍历模式按钮，检查是否被点击，如果被点击则更新settings对象，检查鼠标点击位置是否在当前按钮的矩形内
                for mode, rect in mode_buttons.items():
                    if rect.collidepoint(mouse_pos): settings.game_mode = mode
                # 遍历皮肤按钮
                for skin, rect in skin_buttons.items():
                    if rect.collidepoint(mouse_pos): settings.snake_skin = skin
                # 遍历Logo按钮
                for logo, rect in logo_buttons.items():
                    if rect.collidepoint(mouse_pos): settings.logo_style = logo
                #增加对背景颜色按钮的点击事件处理
                for color, rect in bgcolor_buttons.items():
                    if rect.collidepoint(mouse_pos): settings.background_color = color
                # 检查最下方的“开始游戏”按钮是否被点击
                if back_button.collidepoint(mouse_pos):
                    # 如果是，则退出结束界面，并返回更新后的settings
                    return "back_to_start", settings

        # 更新
        for p in particles: p.update()
        for h in hexagons: h.update()

        # 1. 绘制新的反向渐变背景
        screen.blit(background_surface, (0, 0))

        # 2. 绘制蓝黄色晕染小分子
        particle_surface = pygame.Surface((screen_w, screen_h), pygame.SRCALPHA)
        for p in particles:
            p.draw(particle_surface, glow_image)
        screen.blit(particle_surface, (0, 0), special_flags=pygame.BLEND_RGBA_ADD)

        # 3. 绘制动态相交六边形
        hex_surface = pygame.Surface((screen_w, screen_h), pygame.SRCALPHA)
        for h in hexagons:
            h.draw(hex_surface)
        screen.blit(hex_surface, (0, 0), special_flags=pygame.BLEND_RGBA_ADD)

        # 4. 绘制UI
        # --- 修改: 为800x800调整了标题和分数的位置 ---
        title_surf = font_title.render("游戏结束", True, (255, 215, 0))
        """
        .render() (渲染 / “盖章”的动作)
        1.font_title 这个“字体对象”自带的一个方法（函数）。render 的意思是“渲染”，在计算机图形学里，它的意思就是“把数据（文字）变成图像（像素）
        2.render() 括号里的三个“配料”（参数）
        ①"游戏结束" (要印的文字） 这是什么？ 一个 Python 字符串 (String)
        ②True (是否平滑 / “抗锯齿”) 这是什么？ 一个布尔值 (Boolean)，True 或 False。它的作用？ 这是在选择“印刷质量”。
        True：开启“抗锯齿”(Anti-aliasing)。render 会尝试让文字的边缘变得平滑，看起来更漂亮、更专业。
        False：关闭“抗锯齿”。文字的边缘会有很明显的“锯齿”，看起来很粗糙、有像素感。
        ③(255, 215, 0) (颜色 / “印泥”)  这是什么？ 一个包含三个数字的元组 (Tuple)，代表 RGB 颜色。
        它的作用？ 告诉 render 函数，你要用什么颜色的“印泥”来盖章
        3.title_surf = ... (结果 / “盖好章的纸”)   这是什么？ 这是一个变量赋值。
        它的作用？ .render() 函数在完成“盖章”工作后，会返回一个全新的 pygame.Surface 对象。
        4.Surface 在 Pygame 里就是“画布”或“图像”的意思。
        所以 title_surf (标题画布) 这个变量，现在就存储了那块“盖好了金色‘游戏结束’字样的、独立的、小小的画布/图片”
        """
        screen.blit(title_surf, title_surf.get_rect(center=(screen_w // 2, 80)))
        score_text = f"最终分数: {final_score}"
        score_surf = font_score.render(score_text, True, (255, 255, 255))
        screen.blit(score_surf, score_surf.get_rect(center=(screen_w // 2, 150)))
        high_score_text = f"当前最高: {load_high_score()}"
        high_score_surf = font_score.render(high_score_text, True, (255, 215, 0))
        screen.blit(high_score_surf, high_score_surf.get_rect(center=(screen_w // 2, 190)))

        # 绘制所有新功能选项按钮的辅助函数和调用
        def draw_options(title, buttons, current_selection, y_pos):
            # 绘制选项标题，如“选择模式”
            title_surf = font_option_title.render(title, True, (255, 255, 255))
            screen.blit(title_surf, title_surf.get_rect(center=(screen_w / 2, y_pos - 31)))
            # 遍历这行所有的按钮
            for key, rect in buttons.items():
                # 检查这个按钮是不是当前被选中的
                is_selected = (key == current_selection)
                # 根据是否被选中，设置不同的颜色（选中为黄色，未选中为蓝色）
                color = (255, 215, 0) if is_selected else (0, 191, 255)
                # 绘制按钮的半透明背景
                pygame.draw.rect(screen, (*color, 30), rect, border_radius=8)
                # 绘制按钮的彩色边框
                pygame.draw.rect(screen, color, rect, 2, border_radius=8)

                ## --- 修改：中文化所有按钮文字 --- ##
                display_text = {
                    'simple': '简单模式', 'ai': '人机对战', 'endless': '无尽模式',
                    'cloud': '云朵Logo', 'aurora': '光晕Logo', 'whale': '鲸鱼Logo',
                    'grey': '灰色背景', 'green': '绿色背景', 'yellow': '黄色背景'
                }
                # 如果是皮肤，则从常量中获取中文名，否则从上面的字典中获取
                text_to_show = SNAKE_SKINS[key]['name'] if title == "贪吃蛇形态" else display_text.get(key, key)

                ## --- 结束修改 --- ##
                # 渲染按钮上的文字
                text_surf = font_option.render(text_to_show, True, (255, 255, 255))
                # 把文字画在按钮的中心
                screen.blit(text_surf, text_surf.get_rect(center=rect.center))

        # --- 修改: 为绘制选项调整了Y坐标 ---
        draw_options("选择模式", mode_buttons, settings.game_mode, start_y)
        draw_options("贪吃蛇形态", skin_buttons, settings.snake_skin, start_y + btn_y_gap)
        draw_options("LOGO样式", logo_buttons, settings.logo_style, start_y + 2 * btn_y_gap)
        #调用绘制函数来显示新的背景颜色选项
        draw_options("背景主题", bgcolor_buttons, settings.background_color, start_y + 3 * btn_y_gap)

        # 绘制主按钮，绘制最下方的“开始新游戏”按钮（带鼠标悬停效果）
        button_color = (255, 215, 0) if back_button.collidepoint(mouse_pos) else (0, 191, 255)
        pygame.draw.rect(screen, (*button_color, 20), back_button, border_radius=8)
        pygame.draw.rect(screen, button_color, back_button, 2, border_radius=8)
        button_text_surf = font_button.render("开始新游戏(ENTER键）", True, (255, 255, 255))
        screen.blit(button_text_surf, button_text_surf.get_rect(center=back_button.center))

        # <--- 【修改 4/4】新增：在主循环末尾，根据标志位绘制退出确认窗口 --->
        # 这个 if 块是绘制的最后一步，确保它会画在所有东西的最上面。
        #这个是弹窗的显示（258行赋初值为false）
        if show_exit_dialog:
            # 1. 绘制半透明黑色遮罩，让背景变暗
            overlay = pygame.Surface((screen_w, screen_h), pygame.SRCALPHA)
            overlay.fill((0, 0, 0, 180))  # 最后一个值180是透明度
            screen.blit(overlay, (0, 0))

            # 2. 绘制对话框背景
            pygame.draw.rect(screen, COLOR_GRADIENT_EDGE, dialog_rect, border_radius=15)
            """
            没写width，默认为0，填充全部颜色，就是第一行是一个实心矩形，
            第二个是只画了边框的的矩形
            """
            pygame.draw.rect(screen, COLOR_PARTICLE_BLUE, dialog_rect, 2, border_radius=15)

            # 3. 绘制对话框文字
            dialog_text_surf = font_dialog_title.render("你确定要退出贪吃蛇吗？", True, (255, 255, 255))
            screen.blit(dialog_text_surf, dialog_text_surf.get_rect(center=(dialog_rect.centerx, dialog_rect.top + 60)))

            # 4. 绘制"确定"按钮
            confirm_color = (255, 215, 0) if confirm_button_rect.collidepoint(mouse_pos) else (0, 191, 255)
            pygame.draw.rect(screen, (*confirm_color, 30), confirm_button_rect, border_radius=8)
            pygame.draw.rect(screen, confirm_color, confirm_button_rect, 2, border_radius=8)
            confirm_text_surf = font_dialog_button.render("确定", True, (255, 255, 255))
            screen.blit(confirm_text_surf, confirm_text_surf.get_rect(center=confirm_button_rect.center))

            # 5. 绘制"取消"按钮
            cancel_color = (255, 215, 0) if cancel_button_rect.collidepoint(mouse_pos) else (0, 191, 255)
            pygame.draw.rect(screen, (*cancel_color, 30), cancel_button_rect, border_radius=8)
            pygame.draw.rect(screen, cancel_color, cancel_button_rect, 2, border_radius=8)
            cancel_text_surf = font_dialog_button.render("取消", True, (255, 255, 255))
            screen.blit(cancel_text_surf, cancel_text_surf.get_rect(center=cancel_button_rect.center))
        # <--- 【修改 4/4】结束 --->

        pygame.display.update()
        clock.tick(60)